<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Object-oriented programming II</title>
<link rel="stylesheet" href="/cfg/format.css" type="text/css">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta name="keywords" content="C#, learn C#, OOP, .NET, Mono, object-oriented programming, programming, language">
<meta name="description" content="This part of the C# tutorial continues describing of the object-oriented programming.">
<meta name="language" content="en">
<meta name="author" content="Jan Bodnar">
<meta name="distribution" content="global">

<script type="text/javascript" src="/lib/jquery.js"></script>
<script type="text/javascript" src="/lib/common.js"></script>

</head>

<body>

<div class="container">

<div id="wide_ad" class="ltow">
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* 160x600, August 2011 */
google_ad_slot = "2484182563";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>
</div>


<div class="content">

<a href="/" title="Home">Home</a>&nbsp;
<a href="..">Contents</a>


<h1>Object-oriented programming II</h1>

<p>
In this chapter of the C# tutorial, we continue description of the OOP.
</p>

<h2>Interfaces</h2>

<p>
A remote control is an interface between the viewer and the TV. It is an interface to this electronic
device. Diplomatic protocol guides all activities in the diplomatic field. Rules of the road are rules
that motorists, cyclists and pedestrians must follow. Interfaces in programming are
analogous to the previous examples. 
</p>

<p>
Interfaces are:
</p>

<ul>
<li>APIs</li>
<li>Contracts</li>
</ul>

<p>
Objects interact with the outside world with the methods, they expose. The actual implementation is not
important to the programmer, or it also might be secret. A company might sell a library and it does not
want to disclose the actual implementation. A programmer might call a Maximize() method on a window
of a GUI toolkit, but knows nothing about how this method is implemented. From this point of view, 
interfaces are methods, through which objects interact with the outside world, without exposing too much
about their inner workings.
</p>

<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* NewSquare */
google_ad_slot = "0364418177";
google_ad_width = 300;
google_ad_height = 250;
//-->
</script> 
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script>


<p>
From the second point of view, interfaces are contracts. If agreed upon, they must be followed. They 
are used to design an architecture of an application. They help organize the code.  
</p>

<p>
Interfaces are fully abstract types. They are declared using the <code>interface</code> keyword. 
Interfaces can only have signatures of methods, properties, events or indexers. 
All interface members implicitly have public access. Interface members cannot have access modifiers specified.
Interfaces cannot have fully implemented methods, nor member fields. A C# class may implement any number of interfaces. A
n interface can also extend any number of interfaces. A class that implements an interface must 
implement all method signatures of an interface.  
</p>

<p>
Interfaces are used to simulate <b>multiple inheritance</b>. A C# class can inherit only from one class. 
A C# class can implement multiple interfaces. Multiple inheritance using the interfaces is not 
about inheriting methods and variables. It is about inheriting ideas or contracts, which are described
by the interfaces. 
</p>

<p>
There is one important distinction between interfaces and abstract classes. Abstract classes provide partial
implementation for classes, that are related in the inheritance hierarchy. Interfaces on the other hand can 
be implemented by classes, that are not related to each other. For example, we have two buttons.
A classic button and a round button. Both inherit from an abstract button class, that provides some
common functionality to all buttons. Implementing classes are related, since all are buttons. 
Another example might have classes Database and SignIn. They are not related to each other. We
can apply an ILoggable interface, that would force them to create a method to do logging. 
</p>

<pre class="code">
using System;


public interface IInfo
{
    void DoInform();   
}

public class Some : IInfo
{
    public void DoInform()
    {
        Console.WriteLine("This is Some Class");
    }
}

public class CSharpApp
{

    static void Main()
    {
        Some sm = new Some();
        sm.DoInform();    
    }    
}
</pre>

<p>
This is a simple C# program demonstrating an interface.
</p>

<pre class="explanation">
public interface IInfo
{
    void DoInform();   
}
</pre>

<p>
This is an interface <code>IInfo</code>. It has the <code>DoInform()</code>
method signature.
</p>

<pre class="explanation">
public class Some : IInfo
</pre>

<p>
We implement the <code>IInfo</code> interface. To implement
a specific interface, we use the colon (:) operator.
</p>

<pre class="explanation">
public void DoInform()
{
    Console.WriteLine("This is Some Class");
}
</pre>

<p>
The class provides an implementation for the <code>DoInform()</code>
method. 
</p>

<hr class="btm">

<p>
The next example shows, how a class can implement multiple
interfaces.
</p>

<pre class="code">
using System;


public interface Device
{
    void SwitchOn();   
    void SwitchOff();
}

public interface Volume
{
    void VolumeUp();   
    void VolumeDown();
}

public interface Pluggable
{
    void PlugIn();   
    void PlugOff();
}

public class CellPhone : Device, Volume, Pluggable
{
    public void SwitchOn() 
    {
        Console.WriteLine("Switching on");
    }

    public void SwitchOff() 
    {
        Console.WriteLine("Switching on");
    }

    public void VolumeUp() 
    {
        Console.WriteLine("Volume up");
    }

    public void VolumeDown() 
    {
        Console.WriteLine("Volume down");
    }

    public void PlugIn() 
    {
        Console.WriteLine("Plugging In");
    }

    public void PlugOff() 
    {
        Console.WriteLine("Plugging Off");
    }
}

public class CSharpApp
{
    static void Main()
    {
        CellPhone cp = new CellPhone();
        cp.SwitchOn();
        cp.VolumeUp();
        cp.PlugIn();
    }    
}
</pre>

<p>
We have a <code>CellPhone</code> class that inherits from three interfaces. 
</p>

<pre class="explanation">
public class CellPhone : Device, Volume, Pluggable
</pre>

<p>
The class implements all three interfaces, which are divided by a comma.
The CellPhone class must implement all method signatures from all three 
interfaces. 
</p>

<pre>
$ ./interface2.exe 
Switching on
Volume up
Plugging In
</pre>

<p>
Running the program. 
</p>

<hr class="btm">

<p>
The next example shows how interfaces can inherit from multiple other
interfaces. 
</p>

<pre class="code">
using System;


public interface IInfo
{
    void DoInform();   
}

public interface IVersion
{
    void GetVersion();   
}

public interface ILog : IInfo, IVersion
{
    void DoLog();   
}

public class DBConnect : ILog
{

    public void DoInform() 
    {
        Console.WriteLine("This is DBConnect class");
    }

    public void GetVersion() 
    {
        Console.WriteLine("Version 1.02");
    }

    public void DoLog() 
    {
        Console.WriteLine("Logging");
    }

    public void Connect()
    {
        Console.WriteLine("Connecting to the database");
    }
}

public class CSharpApp
{
    static void Main()
    {
        DBConnect db = new DBConnect();
        db.DoInform();
        db.GetVersion();
        db.DoLog();
        db.Connect();
    }    
}
</pre>

<p>
We define three interfaces. We can organize interfaces in a hierarchy.
</p>

<pre class="explanation">
public interface ILog : IInfo, IVersion
</pre>

<p>
The <code>ILog</code> interface inherits from two other interfaces.
</p>

<pre class="explanation">
public void DoInform() 
{
    Console.WriteLine("This is DBConnect class");
}
</pre>

<p>
The <code>DBConnect</code> class implements the <code>DoInform()</code> method. 
This method was inherited by the <code>ILog</code> interface, 
which the class implements. 
</p>

<pre>
$ ./interface3.exe 
This is DBConnect class
Version 1.02
Logging
Connecting to the database
</pre>

<p>
Output.
</p>

<h2>Polymorphism</h2>

<p>
The polymorphism is the process of using an operator or function in different ways for different data input.
In practical terms, polymorphism means that if class B inherits from class A, it doesn't have to
inherit everything about class A; it can do some of the things that class A does differently. (wikipedia)
</p>

<p>
In general, polymorphism is the ability to appear in different forms. Technically, it is the ability 
to redefine methods for derived classes. Polymorphism is concerned with the application of specific implementations
to an interface or a more generic base class. 
</p>

<p>
Polymorphism is the ability to redefine methods for derived classes.
</p>

<pre class="code">
using System;

public abstract class Shape
{
    protected int x;
    protected int y;
    
    public abstract int Area();
}

public class Rectangle : Shape
{    
    public Rectangle(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public override int Area()
    {
        return this.x * this.y;
    }
}

public class Square : Shape 
{
    public Square(int x)
    {
        this.x = x;
    }

    public override int Area()
    {
        return this.x * this.x;
    }
}

public class CSharpApp
{
    static void Main()
    {
        Shape[] shapes = { new Square(5), 
            new Rectangle(9, 4), new Square(12) }; 

        foreach (Shape shape in shapes)
        {
            Console.WriteLine(shape.Area());
        }
    }
}
</pre>

<p>
In the above program, we have an abstract <code>Shape</code> class. 
This class morphs into two descendant classes, <code>Rectangle</code> 
and <code>Square</code>. Both provide their own implementation of
the <code>Area()</code> method. Polymorphism brings flexibility 
and scalability to the OOP systems. 
</p>

<pre class="explanation">
public override int Area()
{
    return this.x * this.y;
}
...
public override int Area()
{
    return this.x * this.x;
}
</pre>

<p>
<code>Rectangle</code> and <code>Square</code> classes have their own 
implementations of the <code>Area()</code> method.
</p>

<pre class="explanation">
Shape[] shapes = { new Square(5), 
    new Rectangle(9, 4), new Square(12) };
</pre>

<p>
We create an array of three Shapes. 
</p>

<pre class="explanation">
foreach (Shape shape in shapes)
{
    Console.WriteLine(shape.Area());
}
</pre>

<p>
We go through each shape and call <code>Area()</code> method on it. 
The compiler calls the correct method for each shape. This
is the essence of polymorphism.
</p>


<h2>Sealed classes</h2>

<p>
The <code>sealed</code> keyword is used to prevent unintended derivation 
from a class. A sealed class cannot be an abstract class. 
</p>

<pre class="code">
using System;

sealed class Math
{
    public static double GetPI()
    {
        return 3.141592;
    }
}

public class Derived : Math
{

    public void Say()
    {
        Console.WriteLine("Derived class");
    }
}

public class CSharpApp
{
    static void Main()
    {
        DerivedMath dm = new DerivedMath();
        dm.Say();
    }
}
</pre>

<p>
In the above program, we have a base Math class. The sole 
purpose of this class is to provide some helpful methods and constants 
to the programmer. (In our case we have only one method for simplicity reasons.) 
It is not created to be inherited from. To prevent uninformed other 
programmers to derive from this class, the creators made the class 
<code>sealed</code>. If you try to compile this program, 
you get the following error: 'DerivedMath' cannot derive from 
sealed class `Math'.
</p>

<h2>Deep copy vs shallow copy</h2>

<p>
Copying of data is an important task in programming. Object is a composite data type in OOP. 
Member field in an object may be stored by value or by reference. Copying may be performed in
two ways. 
</p>

<p>
The <b>shallow copy</b> copies all values and references into a new instance. The data to which a
reference is pointing is not copied; only the pointer is copied. The new references
are pointing to the original objects. Any changes to the reference members affect both objects. 
</p>

<p>
The <b>deep copy</b> copies all values into a new instance. In case of members that are stored as
references a deep copy performs a deep copy of data, that is being referenced. A new copy of a referenced
object is created. And the pointer to the newly created object is stored. Any changes to those referenced
objects will not affect other copies of the object. Deep copies are fully replicated objects. 
</p>

<p>
If a member field is a value type, a bit-by-bit copy of the field is performed. 
If the field is a reference type, the reference is copied but the referred object is not; 
therefore, the reference in the original object and the reference 
in the clone point to the same object. (a clear explanation from programmingcorner.blogspot.com)
</p>

<p>
The next two examples will perform a shallow and a deep copy on objects. 
</p>

<pre class="code">
using System;


public class Color
{
    public int red;
    public int green;
    public int blue;

    public Color(int red, int green, int blue)
    {
        this.red = red;
        this.green = green;
        this.blue = blue;
    }
}

public class MyObject : ICloneable
{
    public int id;
    public string size;
    public Color col;

    public MyObject(int id, string size, Color col)
    {
        this.id = id;
        this.size = size;
        this.col = col;
    }

    public object Clone()
    {
        return new MyObject(this.id, this.size, this.col);
    }

    public override string ToString()
    {
        string s;
        s = String.Format("id: {0}, size: {1}, color:({2}, {3}, {4})", 
            this.id, this.size, this.col.red, this.col.green, this.col.blue);
        return s;
    }
} 

public class CSharpApp
{
    static void Main()
    {
        Color col = new Color(23, 42, 223);    
        MyObject obj1 = new MyObject(23, "small", col);
        
        MyObject obj2 = (MyObject) obj1.Clone();
        
        obj2.id += 1;
        obj2.size = "big";         
        obj2.col.red = 255;
         
        Console.WriteLine(obj1);
        Console.WriteLine(obj2);
    }
}
</pre>

<p>
This is an example of a shallow copy. 
We define two custom objects. MyObject and Color. The MyObject object
will have a reference to the Color object. 
</p>

<pre class="explanation">
public class MyObject : ICloneable
</pre>

<p>
We should implement <code>ICloneable</code> interface for 
objects, which we are going to clone. 
</p>

<pre class="explanation">
public object Clone()
{
    return new MyObject(this.id, this.size, this.col);
}
</pre>

<p>
The <code>ICloneable</code> interface forces us
to create a <code>Clone()</code> method. This
method returns a new object with copied values.
</p>

<pre class="explanation">
Color col = new Color(23, 42, 223);  
</pre>

<p>
We create an instance of the Color object. 
</p>

<pre class="explanation">
MyObject obj1 = new MyObject(23, "small", col);
</pre>

<p>
An instance of the MyObject object is created. It passes the
instance of the Color object to its constructor. 
</p>

<pre class="explanation">
MyObject obj2 = (MyObject) obj1.Clone();
</pre>

<p>
We create a shallow copy of the obj1 object and assign it
to the obj2 variable. The Clone() method returns an Object
and we expect MyObject. This is why we do explicit casting. 
</p>


<pre class="explanation">
obj2.id += 1;
obj2.size = "big";         
obj2.col.red = 255;
</pre>

<p>
Here we modify the member fields of the copied object. 
We increment the id, change the size to "big" and change 
the red part of the color object.
</p>

<pre class="explanation">
Console.WriteLine(obj1);
Console.WriteLine(obj2);
</pre>

<p>
The <code>Console.WriteLine()</code> method calls the
<code>ToString()</code> method of the obj2 object, which
returns the string representation of the object. 
</p>

<pre>
$ ./shallowcopy.exe 
id: 23, size: small, color:(255, 42, 223)
id: 24, size: big, color:(255, 42, 223)
</pre>

<p>
We can see, that the ids are different. 23 vs 24. The size is different.
"small" vs "big". But the red part of the color object is same for both 
instances. 255. Changing member values of the cloned object (id, size) 
did not affect the original object. Changing members of the referenced 
object (col) has affected the original object too. In other words, both 
objects refer to the same color object in memory.
</p>

<hr class="btm">

<p>
<b>Deep Copy</b> To change this behaviour, we will do a deep copy next. 
</p>

<pre class="code">
using System;


public class Color : ICloneable
{
    public int red;
    public int green;
    public int blue;

    public Color(int red, int green, int blue)
    {
        this.red = red;
        this.green = green;
        this.blue = blue;
    }
    
    public object Clone()
    {
        return new Color(this.red, this.green, this.blue);
    }
}

public class MyObject : ICloneable
{
    public int id;
    public string size;
    public Color col;

    public MyObject(int id, string size, Color col)
    {
        this.id = id;
        this.size = size;
        this.col = col;
    }

    public object Clone()
    {
        return new MyObject(this.id, this.size, 
            (Color) this.col.Clone());
    }

    public override string ToString()
    {
        string s;
        s = String.Format("id: {0}, size: {1}, color:({2}, {3}, {4})", 
            this.id, this.size, this.col.red, this.col.green, this.col.blue);
        return s;
    }
} 

public class CSharpApp
{
    static void Main()
    {
        Color col = new Color(23, 42, 223);    
        MyObject obj1 = new MyObject(23, "small", col);
        
        MyObject obj2 = (MyObject) obj1.Clone();
        
        obj2.id += 1;
        obj2.size = "big";         
        obj2.col.red = 255;
         
        Console.WriteLine(obj1);
        Console.WriteLine(obj2);
    }
}
</pre>

<p>
In this program, we perform a deep copy on object.
</p>

<pre class="explanation">
public class Color : ICloneable
</pre>

<p>
Now the Color class implements the <code>ICloneable</code>
interface.
</p>

<pre class="explanation">
public object Clone()
{
    return new Color(this.red, this.green, this.blue);
}
</pre>

<p>
We have a <code>Clone()</code> method for the Color class
too. This helps to create a copy of a referenced object.
</p>


<pre class="explanation">
public object Clone()
{
    return new MyObject(this.id, this.size, 
        (Color) this.col.Clone());
}
</pre>

<p>
Now, when we clone the MyObject, we call the <code>Clone()</code>
method upon the col reference type. This way we have a copy of 
a color value too.
</p>


<pre>
$ ./deepcopy.exe 
id: 23, size: small, color:(23, 42, 223)
id: 24, size: big, color:(255, 42, 223)
</pre>

<p>
Now the red part of the referenced Color object is not the same. 
The original object has retained its previous 23 value.
</p>

<h2>Exceptions</h2>

<p>
Exceptions are designed to handle the occurrence of exceptions, special 
conditions that change the normal flow of program execution. Exceptions 
are raised or thrown, initiated. 
</p>

<p>
During the execution of our application,
many things might go wrong. A disk might get full and we cannot save our file.
An Internet connection might go down and our application tries to connect to a site.
All these might result in a crash of our application. To prevent happening this,
we must cope with all possible errors that might occur. For this, we can use the 
exception handling.
</p>

<p>
The <code>try</code>, <code>catch</code> and <code>finally</code> 
keywords are used to work with exceptions. 
</p>

<pre class="code">
using System;


public class CSharpApp
{
    static void Main()
    {
        int x = 100;
        int y = 0;
        int z;

        try
        {
            z = x / y;
        } catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}
</pre>

<p>
In the above program, we intentionally divide a number by zero. 
This leads to an error.
</p>

<pre class="explanation">
try
{
    z = x / y;
} catch (Exception e)
</pre>

<p>
Statements that are error prone are placed after the <code>try</code>
keyword.
</p>


<pre class="explanation">
} catch (Exception e)
{
    Console.WriteLine(e.Message);
}
</pre>

<p>
Exception types follow the <code>catch</code> keyword. In our case we 
have a generic <code>Exception</code> which will catch an exception of 
any type. There are some generic exceptions and some more specific. 
Statements that follow the <code>catch</code> keyword are executed, when 
an error occurs. When an exception occurs, an exception object is created. 
From this object we get the <code>Message</code> property and print it 
to the console. 
</p>

<pre>
$ ./zerodivision.exe 
Division by zero
</pre>

<p>
Output of the code example.
</p>

<hr class="btm">

<p>
Any uncaught exception in the current context propagates to a higher 
context and looks for an appropriate catch block to handle it. 
If it can't find any suitable catch blocks, the default mechanism of 
the .NET runtime will terminate the execution of the entire program.
</p>

<pre class="code">
using System;


public class CSharpApp
{
    static void Main()
    {
        int x = 100;
        int y = 0;

        int z = x / y;

        Console.WriteLine(z);  
    }
}
</pre>

<p>
In this program, we divide by zero. There is no no custom
exception handling. 
</p>

<pre>
$ ./uncaught.exe 

Unhandled Exception: System.DivideByZeroException: Division by zero
  at CSharpApp.Main () [0x00000] 
</pre>

<p>
The Mono C# compiler gives the above error message.
</p>

<hr class="btm">


<pre class="code">
using System;
using System.IO;

public class CSharpApp
{

    static void Main()
    {
        FileStream fs = new FileStream("langs", FileMode.OpenOrCreate);

        try
        {
            StreamReader sr = new StreamReader(fs);
            string line;

            while ((line = sr.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        } catch (IOException e)
        {
            Console.WriteLine("IO Error");
            Console.WriteLine(e.Message);
        } finally
        {
            Console.WriteLine("finally");
            if (fs.CanRead)
            { 
                fs.Close();
            }
        }
    }
}
</pre>

<p>
The statements following the <code>finally</code> keyword are always executed.
It is often used to clean-up tasks, such as closing files or clearing buffers.
</p>

<pre class="explanation">
} catch (IOException e)
{
    Console.WriteLine("IO Error");
    Console.WriteLine(e.Message);
} finally
</pre>

<p>
In this case, we catch for a specific <code>IOException</code> exception.
</p>

<pre class="explanation">
} finally
{
    Console.WriteLine("finally");
    if (fs.CanRead)
    { 
        fs.Close();
    }
}
</pre>

<p>
These lines guarantee that the file handler is closed.
</p>

<pre>
$ cat langs
C#
Python
C++
Java
$ ./finally.exe 
C#
Python
C++
Java
finally
</pre>

<p>
We show the contents of the langs file with the cat command and
output of the program. 
</p>

<hr class="btm">

<pre class="code">
using System;
using System.IO;

public class CSharpApp
{

    static void Main()
    {
        int x;
        int y;
        double z;

        try
        {
            Console.Write("Enter first number: ");
            x = Convert.ToInt32(Console.ReadLine());

            Console.Write("Enter second number: ");
            y = Convert.ToInt32(Console.ReadLine());

            z = x / y;
            Console.WriteLine("Result: {0:D} / {1:D} = {2:D}", x, y, z);

        } catch (DivideByZeroException e)
        {
            Console.WriteLine("Cannot divide by zero");
            Console.WriteLine(e.Message);
        } catch (FormatException e)
        {
            Console.WriteLine("Wrong format of number.");
            Console.WriteLine(e.Message);
        } catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}
</pre>

<p>
In this example, we catch for various exceptions. Note that more specific 
exceptions should precede the generic ones. We read two numbers from the 
console and check for zero division error and for wrong format of number. 
</p>

<pre>
$ ./multipleexceptions.exe 
Enter first number: we
Wrong format of number.
Input string was not in the correct format
</pre>

<p>
Running the example. 
</p>

<hr class="btm">

<pre class="code">
using System;

class BigValueException : Exception
{        
    public BigValueException(string msg) : base(msg) {}
}

public class CSharpApp
{
    static void Main()
    {
        int x = 340004;
        const int LIMIT = 333;
        
        try
        { 
            if (x > LIMIT)
            {
                throw new BigValueException("Exceeded the maximum value");
            }
        } catch (BigValueException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}
</pre>

<p>
Let's say, we have a situation in which we cannot deal with big numbers. 
</p>

<pre class="explanation">
class BigValueException : Exception
</pre>

<p>
We have a BigValueException class. This class derives from the 
built-in <code>Exception</code> class.
</p>

<pre class="explanation">
const int LIMIT = 333;
</pre>

<p>
Numbers bigger than this constant are considered to be "big" by 
our program.
</p>


<pre class="explanation">
public BigValueException(string msg) : base(msg) {}
</pre>

<p>
Inside the constructor, we call the parent's constructor. 
We pass the message to the parent. 
</p>

<pre class="explanation">
if (x > LIMIT)
{
    throw new BigValueException("Exceeded the maximum value");
}
</pre>

<p>
If the value is bigger than the limit, we throw our custom exception.
We give the exception a message "Exceeded the maximum value". 
</p>

<pre class="explanation">
} catch (BigValueException e)
{
    Console.WriteLine(e.Message);
}
</pre>

<p>
We catch the exception and print its message to the console. 
</p>


<p>
In this part of the C# tutorial, we continued the discussion of 
the object-oriented programming in C#.
</p>


<div class="botNav, center">
<span class="botNavItem"><a href="/">Home</a></span> ‡ <span class="botNavItem"><a href="..">Contents</a></span> ‡
<span class="botNavItem"><a href="#">Top of Page</a></span>
</div>


<div class="footer">
<div class="signature">
<a href="/">ZetCode</a> last modified November 3, 2010  <span class="copyright">&copy; 2007 - 2013 Jan Bodnar</span>
</div>
</div>

</div> <!-- content -->

</div> <!-- container -->

</body>
</html>
